app/components/graphView.tsx (1)

Line range hint 105-166: Improve double-click detection implementation.

The current implementation has potential issues:

1. The double-click detection uses a fixed 1000ms threshold which might not match the system's double-click speed setting.
2. The implementation doesn't handle the case where a user clicks different nodes within the threshold.

Consider this improved implementation:

-const lastClick = useRef<{ date: Date, name: string }>({ date: new Date(), name: "" })
+const lastClick = useRef<{ time: number, id: number }>({ time: 0, id: 0 })

-const isDoubleClick = now.getTime() - date.getTime() < 1000 && name === node.name
+const isDoubleClick = (now.getTime() - lastClick.current.time < 500) && (lastClick.current.id === node.id)
+lastClick.current = { time: now.getTime(), id: node.id }

app/components/chat.tsx (1)

Line range hint 157-215: Improve zoom functionality implementation.

Several improvements can be made to the zoom functionality:

1. The setTimeout with 0ms delay is unnecessary
2. Magic numbers should be constants
3. Add proper error handling for undefined chart

Apply these changes:

+const ZOOM_DURATION = 1000;
+const ZOOM_PADDING = 150;

 const handleSetSelectedPath = (p: PathData) => {
   const chart = chartRef.current
   
-  if (!chart) return
+  if (!chart) {
+    console.warn('Chart reference is not available');
+    return;
+  }
   
   // ... rest of the function ...
   
-  setTimeout(() => {
-    chart.zoomToFit(1000, 150, (n: NodeObject<Node>) => p.nodes.some(node => node.id === n.id));
-  }, 0)
+  chart.zoomToFit(ZOOM_DURATION, ZOOM_PADDING, (n: NodeObject<Node>) => p.nodes.some(node => node.id === n.id));
 }

🧰 Tools

🪛 Biome (1.9.4)

[error] 163-163: Comparing to itself is potentially pointless.

(lint/suspicious/noSelfCompare)

e2e/tests/chat.spec.ts (1)

113-113: Remove unnecessary empty line within the loop.

The empty line within the loop affects readability without adding value.

    for (let i = 0; i < 3; i++) {
      await chat.sendMessage(Node_Question);
      const result = await chat.getTextInLastChatElement();
      const number = result.match(/\d+/g)?.[0]!;
      responses.push(number);
-      
    }

app/components/model.ts (2)

179-215: Add error handling for edge cases.

While the node creation logic is sound, it would benefit from additional error handling for edge cases.

      let source = this.nodesMap.get(edgeData.src_node)
      let target = this.nodesMap.get(edgeData.dest_node)

+     if (edgeData.src_node === undefined || edgeData.dest_node === undefined) {
+       console.warn('Invalid edge data: Missing source or destination node ID');
+       return;
+     }

      if (!source) {

---

229-253: Add documentation for curve calculation logic.

The curve calculation logic is complex and would benefit from documentation explaining the mathematical reasoning.

Add a comment block explaining the curve calculation:

+    // Calculate curve values for graph edges:
+    // - For self-loops (start === end):
+    //   - Even indices: negative values starting from -3
+    //   - Odd indices: positive values starting from 2
+    // - For regular edges:
+    //   - Even indices: negative values starting from 0
+    //   - Odd indices: positive values starting from 1
+    // The final curve value is scaled by 0.1 to create subtle curves
     newElements.links.forEach(link => {

e2e/logic/POM/codeGraph.ts (1)

284-285: Consider removing redundant delay.

The code waits for the loading image to be hidden and then adds an additional 2-second delay, which might be unnecessary.

Consider removing the redundant delay:

 async getTextInLastChatElement(): Promise<string>{
     await this.page.waitForSelector('img[alt="Waiting for response"]', { state: 'hidden' });
-    await delay(2000);
     return (await this.lastElementInChat.textContent())!;
 }

app/components/chat.tsx (1)

Line range hint 272-313: Extract common zoom functionality.

The zoom logic is duplicated between handleSetSelectedPath and handleSubmit. Consider extracting it into a reusable function.

Apply these changes:

+const ZOOM_DURATION = 1000;
+const ZOOM_PADDING = 150;
+
+const zoomToNodes = (chart: ForceGraphMethods, nodes: any[]) => {
+  if (!chart) {
+    console.warn('Chart reference is not available');
+    return;
+  }
+  chart.zoomToFit(ZOOM_DURATION, ZOOM_PADDING, (n: NodeObject<Node>) => 
+    nodes.some(node => node.id === n.id)
+  );
+};

 const handleSubmit = async () => {
   const chart = chartRef.current
   
   if (!chart) return
   
   // ... rest of the function ...
   
-  setTimeout(() => {
-    chart.zoomToFit(1000, 150, (n: NodeObject<Node>) => 
-      formattedPaths.some(p => p.nodes.some(node => node.id === n.id))
-    );
-  }, 0)
+  zoomToNodes(chart, formattedPaths.flatMap(p => p.nodes));
 }

 const handleSetSelectedPath = (p: PathData) => {
   // ... rest of the function ...
-  setTimeout(() => {
-    chart.zoomToFit(1000, 150, (n: NodeObject<Node>) => 
-      p.nodes.some(node => node.id === n.id)
-    );
-  }, 0)
+  zoomToNodes(chart, p.nodes);
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

app/components/Input.tsx (1)

Line range hint 201-201: Warning: Dynamic Tailwind class names may not work in production.

The dynamic class name bg-${colorName} might not survive Tailwind's purge in production. Consider using style objects or safelist these color classes in your Tailwind config.

Example safelist configuration in tailwind.config.js:

module.exports = {
  safelist: [
    {
      pattern: /bg-(red|blue|green|yellow|purple|pink|indigo|gray)-/,
      variants: ['hover', 'focus', 'active']
    }
  ]
}

app/components/Input.tsx (1)

Line range hint 147-160: Consider extracting input validation logic.

While the validation works correctly, consider extracting it into a reusable function for better maintainability.

+const INVALID_CHARS_PATTERN = /[%*()\-\[\]{};:"|~]/;
+const getInvalidCharacterMessage = (char: string) => 
+  `The character "${char}" is not allowed in this field.`;
+
+const validateInput = (value: string): { isValid: boolean; message: string } => {
+  const match = value.match(INVALID_CHARS_PATTERN);
+  return match 
+    ? { isValid: false, message: getInvalidCharacterMessage(match[0]) }
+    : { isValid: true, message: '' };
+};
+
 onChange={(e) => {
     const newVal = e.target.value
-    const invalidChars = /[%*()\-\[\]{};:"|~]/;
-
-    if (invalidChars.test(newVal)) {
-        e.target.setCustomValidity(`The character "${newVal.match(invalidChars)?.[0]}" is not allowed in this field.`);
+    const { isValid, message } = validateInput(newVal);
+    if (!isValid) {
+        e.target.setCustomValidity(message);
         e.target.reportValidity();
         return;
     }
     e.target.setCustomValidity('');
     onValueChange({ name: newVal })
 }}

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

.github/dependabot.yml (1)

13-16: Group name suggests minor updates but only patches are included.

The group is named npm-minor-patch but only includes "patch" in update-types. This naming could be confusing. Consider either:

1. Renaming to npm-patch if only patch updates are intended, or
2. Adding "minor" to update-types if minor updates should also be grouped.

💡 Option 1: Rename to match behavior

     groups:
-      npm-minor-patch:
+      npm-patch:
         update-types:
           - "patch"

💡 Option 2: Include minor updates

     groups:
       npm-minor-patch:
         update-types:
+          - "minor"
           - "patch"

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/dependabot.yml around lines 13 - 16, The dependabot group name
npm-minor-patch does not match its update-types (only "patch"); either rename
the group to npm-patch or add "minor" to update-types to match intent—update the
groups -> npm-minor-patch name or modify the update-types array (the keys
involved are groups, npm-minor-patch and update-types) accordingly so the config
and naming are consistent.

e2e/logic/utils.ts (2)

52-54: Consider adding type annotations for improved type safety.

The function signature uses any[] and returns any, which reduces type safety. If the node structure is known, consider using a more specific type or generic.

💡 Optional: Type-safe alternative

-export function findNodeByName(nodes: any[], nodeName: string): any {
+export function findNodeByName<T extends { name?: string; data?: { name?: string } }>(
+  nodes: T[], 
+  nodeName: string
+): T | undefined {
     return nodes.find((node) => node.name === nodeName || node.data?.name === nodeName);
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/logic/utils.ts` around lines 52 - 54, The findNodeByName function
currently uses any[] and any; replace these with a type-safe signature by
introducing a Node-like shape or a generic: define or use an interface with
optional fields name?: string and data?: { name?: string } and change
findNodeByName to accept nodes of that type (or a generic T extends that shape)
and return T | undefined instead of any; update any callsites if necessary to
satisfy the new return type.

---

16-35: Consider edge case: function returns potentially unstable text.

The function returns stableText at the end even if the text never stabilized (i.e., it kept changing until timeout). This might be the intended behavior, but consider throwing an error or logging a warning when timeout is reached without stabilization to help debug flaky tests.

💡 Optional: Add timeout warning

     for (let i = 0; i < maxChecks; i++) {
         stableText = await locator.textContent() ?? "";
         if (stableText === previousText && stableText.trim().length > 0) {
             return stableText;
         }
         previousText = stableText;
         await locator.page().waitForTimeout(pollingInterval);
     }
 
+    console.warn(`Text did not stabilize within ${timeout}ms, returning last value`);
     return stableText;
 };

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/logic/utils.ts` around lines 16 - 35, waitForStableText currently returns
the last-read stableText even if the loop timed out without stabilization;
update the end of waitForStableText to treat timeout as a failure: throw an
Error (or at minimum log a warning) indicating the text never stabilized,
include contextual info (the last observed stableText, locator description or
string, and the timeout value) so tests can fail fast and debugging is easier;
locate this logic in the waitForStableText function and replace the final return
stableText with a thrown error or a process/test logger call as appropriate for
the test runner.

package.json (1)

29-29: Add @types/d3 to devDependencies for TypeScript support.

While d3@^7.9.0 does not include built-in TypeScript declarations, d3 is not currently imported in the codebase. However, since the library is now a dependency, adding types ahead of time will prevent TypeScript compilation issues when it's used. Install via DefinitelyTyped:

"@types/d3": "^7.4.3"

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@package.json` at line 29, Add the DefinitelyTyped declarations for D3 by
adding "@types/d3": "^7.4.3" to devDependencies in package.json so TypeScript
has typings when d3 is imported; update the package.json devDependencies block
(referencing the existing "d3" dependency) and run npm/yarn install to persist
the change.

lib/utils.ts (3)

2-2: Unused import: GraphNode.

GraphNode is imported from @falkordb/canvas but is not used anywhere in this file.

♻️ Proposed fix

-import FalkorDBCanvas, { GraphNode } from "@falkordb/canvas"
+import FalkorDBCanvas from "@falkordb/canvas"

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@lib/utils.ts` at line 2, The import includes an unused symbol GraphNode from
`@falkordb/canvas`; remove GraphNode from the import statement (leave
FalkorDBCanvas) to eliminate the unused import warning and keep imports minimal.

---

7-10: Consider stronger typing instead of any[].

Using any[] for nodes and links reduces type safety. Consider using the imported Node and Link types for better compile-time checks.

♻️ Proposed fix

+import { Link, Node } from "@/app/components/model"
+
 export type PathData = {
-  nodes: any[]
-  links: any[]
+  nodes: Node[]
+  links: Link[]
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@lib/utils.ts` around lines 7 - 10, The PathData type currently uses any[] for
nodes and links which reduces type safety; update the PathData definition in
lib/utils.ts to use the specific imported Node and Link types (i.e., nodes:
Node[] and links: Link[]), add/import those types if they are not already
imported, and adjust any call sites or tests that relied on any[] to satisfy the
stronger types.

---

31-36: Consider stronger typing for paths property.

The paths property uses any[] for both nodes and links. This could leverage the PathData type defined above for consistency and type safety.

♻️ Proposed fix

 export interface Message {
   type: MessageTypes;
   text?: string;
-  paths?: { nodes: any[], links: any[] }[];
+  paths?: PathData[];
   graphName?: string;
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@lib/utils.ts` around lines 31 - 36, The Message interface's paths property is
weakly typed using any[]; replace it with the existing PathData type for
stronger typing: change paths?: { nodes: any[], links: any[] }[] to paths?:
PathData[] (or Array<PathData>) in the Message interface so it uses the PathData
definition above and preserves optionality. Ensure PathData is visible in the
same module (or imported) so the Message type compiles.

app/components/toolbar.tsx (1)

64-64: Inconsistent title casing.

The title attribute uses camelCase "downloadImage" while other buttons use title case like "Zoom In", "Zoom Out", and "Center". Consider using consistent casing for accessibility and consistency.

♻️ Proposed fix

             <button
                 className="hidden md:block control-button"
-                title="downloadImage"
+                title="Download Image"
                 onClick={handleDownloadImage}
             >

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/components/toolbar.tsx` at line 64, The title attribute for the download
button ("downloadImage") is using camelCase while other buttons use Title Case,
causing inconsistent accessibility labels; update the title attribute in the
toolbar component (the element with title="downloadImage") to use Title Case
e.g. "Download Image" to match "Zoom In"/"Zoom Out"/"Center" and ensure
consistency across the toolbar UI.

app/api/repo/route.ts (1)

45-45: Hardcoded ignore list may not be appropriate for all repositories.

The ignore array is hardcoded with specific directory patterns. This may not apply universally to all repositories being analyzed. Consider making this configurable via environment variables or request parameters.

♻️ Proposed configuration approach

+const DEFAULT_IGNORE = ["./.github", "./sbin", "./.git", "./deps", "./bin", "./build"];
+
 export async function POST(request: NextRequest) {
   const repo_url = request.nextUrl.searchParams.get('url');
+  const customIgnore = request.nextUrl.searchParams.get('ignore');
+  const ignore = customIgnore ? JSON.parse(customIgnore) : DEFAULT_IGNORE;
   // ...
   const result = await fetch(`${url}/${isLocal ? "analyze_folder" : "analyze_repo"}`, {
     method: 'POST',
-    body: JSON.stringify({ repo_url, ignore: ["./.github", "./sbin", "./.git", "./deps", "./bin", "./build"] }),
+    body: JSON.stringify({ repo_url, ignore }),

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/api/repo/route.ts` at line 45, The hardcoded ignore array in the request
body (body: JSON.stringify({ repo_url, ignore: [...] })) should be made
configurable: update the handler in app/api/repo/route.ts (the function that
constructs this body) to accept an optional ignore list from the incoming
request payload (e.g., request.body.ignore) and/or read a fallback from an
environment variable (e.g., REPO_IGNORE_LIST as JSON or comma-separated); if
neither is provided, fall back to the current default array. Validate/parses the
env or request value into an array before including it in JSON.stringify so
existing behavior remains unchanged when no config is supplied.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

playwright.config.ts (1)

22-23: ⚠️ Potential issue | 🟡 Minor

Update the stale CI parallelism comment.
Line 22 says CI opts out of parallel tests, but Line 23 explicitly sets 3 workers on CI.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@playwright.config.ts` around lines 22 - 23, The comment above the Playwright
config is stale: it claims CI opts out of parallel tests but the workers
property explicitly sets workers: process.env.CI ? 3 : undefined. Fix by making
them consistent: either change the comment to state that CI runs with 3 workers
(e.g., "Use 3 workers on CI") or change the code to opt out (set workers:
process.env.CI ? undefined : undefined or workers: process.env.CI ? 1 :
undefined) depending on intent; update the comment near the workers property to
accurately describe the behavior of the workers setting.

README.md (2)

109-109: ⚠️ Potential issue | 🟡 Minor

Fix the GitHub Issues link.

The link points to GraphRAG-SDK but this README is for the code-graph repository.

🔧 Proposed fix

-* [GitHub Issues](https://github.com/FalkorDB/GraphRAG-SDK/issues)
+* [GitHub Issues](https://github.com/FalkorDB/code-graph/issues)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@README.md` at line 109, Update the GitHub Issues link in README.md: replace
the existing link text "[GitHub
Issues](https://github.com/FalkorDB/GraphRAG-SDK/issues)" so it points to the
code-graph repository issues URL (e.g.,
https://github.com/FalkorDB/code-graph/issues), ensuring the "[GitHub Issues]"
entry now references the correct repository; keep the link label unchanged.

---

9-9: ⚠️ Potential issue | 🟡 Minor

Remove stray character.

Line 9 contains a lone - which appears to be a leftover from editing.

🔧 Proposed fix

-

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@README.md` at line 9, Remove the stray lone '-' character found in the README
(the isolated dash on line 9) by deleting that character so the file contains
only intended content; ensure no other stray punctuation remains and run a quick
preview to confirm formatting is unchanged.

app/globals.css (1)

132-139: ⚠️ Potential issue | 🟡 Minor

Remove duplicate @layer base declaration.

This block duplicates the @layer base declaration at lines 85-94. Additionally, line 137 misses font-roberto that exists in the original at line 91.

🔧 Proposed fix

-@layer base {
-  * {
-    `@apply` border-border;
-  }
-  body {
-    `@apply` bg-background text-foreground;
-  }
-}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/globals.css` around lines 132 - 139, Remove the duplicate `@layer` base
block and merge its rules into the existing `@layer` base (avoid repeating the
`@layer` base declaration); specifically ensure the body selector inside the
retained `@layer` base includes the missing font utility by adding the
font-roberto utility to the existing body `@apply` (so body uses bg-background
text-foreground and font-roberto) and keep the universal * { `@apply`
border-border } rule in that single `@layer` base.

app/components/dataPanel.tsx (1)

21-27: ⚠️ Potential issue | 🟡 Minor

Remove duplicated isPathSelected from excludedProperties.

The same key appears twice, which is redundant and easy to miss in future edits.

Suggested fix

     "curve",
     "__indexColor",
-    "isPathSelected",
     "__controlPoints",

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/components/dataPanel.tsx` around lines 21 - 27, The excludedProperties
array contains a duplicate string "isPathSelected"; remove the redundant
"isPathSelected" entry from the excludedProperties definition (leave a single
occurrence) to avoid redundancy and potential confusion when editing, locating
the array by the symbol name excludedProperties in dataPanel.tsx and updating
that list accordingly.

e2e/tests/canvas.spec.ts (1)

222-225: ⚠️ Potential issue | 🟡 Minor

Remove unsafe non-null assertions before API/path assertions.

Lines 222, 224, and 225 still rely on ! for node ids; this was already flagged and remains brittle.

Suggested fix

       expect(firstNodeRes).toBeDefined();
       expect(secondNodeRes).toBeDefined();
+      if (!firstNodeRes || !secondNodeRes) throw new Error("Path nodes were not found in graph payload");

       const api = new ApiCalls();
-      const response = await api.showPath(GRAPHRAG_SDK ,firstNodeRes!.id, secondNodeRes!.id);
+      const response = await api.showPath(GRAPHRAG_SDK, firstNodeRes.id, secondNodeRes.id);
       const callsRelationObject = response.result.paths[0].find(item => item.relation === "CALLS")
-      expect(callsRelationObject?.src_node).toBe(firstNodeRes!.id);
-      expect(callsRelationObject?.dest_node).toBe(secondNodeRes!.id);
+      expect(callsRelationObject?.src_node).toBe(firstNodeRes.id);
+      expect(callsRelationObject?.dest_node).toBe(secondNodeRes.id);

#!/bin/bash
# Verify remaining non-null id assertions in canvas tests
rg -nP '!\.id' e2e/tests/canvas.spec.ts

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/tests/canvas.spec.ts` around lines 222 - 225, Replace unsafe non-null
assertions by asserting presence and guarding before accessing ids: before
calling api.showPath(GRAPHRAG_SDK, firstNodeRes!.id, secondNodeRes!.id) ensure
firstNodeRes and secondNodeRes are defined (e.g.,
expect(firstNodeRes).toBeDefined(); expect(secondNodeRes).toBeDefined()) and
then call showPath with their .id without using `!`; after getting response,
assert response.result.paths exists and has at least one path, find
callsRelationObject, and assert callsRelationObject is defined before checking
callsRelationObject.src_node and callsRelationObject.dest_node (use
expect(callsRelationObject).toBeDefined();
expect(callsRelationObject!.src_node).toBe(firstNodeRes.id); etc.).

e2e/tests/chat.spec.ts (1)

69-87: ⚠️ Potential issue | 🟡 Minor

Avoid non-null assertions after optional chaining in regex extraction.

Lines 69 and 85 can fail with unclear errors when the regex does not match.

Suggested fix

       const result = await chat.getTextInLastChatElement();
-      const number = result.match(/\d+/g)?.[0]!;
+      const match = result.match(/\d+/g);
+      expect(match?.[0]).toBeDefined();
+      const number = match![0];
@@
     const uiResponse = await chat.getTextInLastChatElement();
-    const number = uiResponse.match(/\d+/g)?.[0]!;
-    
-    expect(number).toEqual(apiResponse.result.response.match(/\d+/g)?.[0]);
+    const uiMatch = uiResponse.match(/\d+/g);
+    const apiMatch = apiResponse.result.response.match(/\d+/g);
+    expect(uiMatch?.[0]).toBeDefined();
+    expect(apiMatch?.[0]).toBeDefined();
+    expect(uiMatch![0]).toEqual(apiMatch![0]);

#!/bin/bash
# Verify remaining optional-chain non-null assertions in this file
rg -nP '\.match\(/\\d\+\/g\)\?\.\[0\]!' e2e/tests/chat.spec.ts

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/tests/chat.spec.ts` around lines 69 - 87, The regex extractions using
optional chaining plus non-null assertion (e.g., uiResponse.match(/\d+/g)?.[0]!
and apiResponse.result.response.match(/\d+/g)?.[0]!) can throw unclear runtime
errors when there's no match; update the test to safely handle missing matches
by removing the non-null assertions and checking that the match exists before
using it: capture the match arrays (from uiResponse.match and
apiResponse.result.response.match), assert they are defined/contain at least one
element (or fail the test with a clear message) and then compare the first
element; look for the variables uiResponse, apiResponse, number and the test
"Validate UI response matches API response for a given question in chat" to
apply this change.

package.json (1)

33-33: ⚠️ Potential issue | 🟠 Major

next version concern appears unresolved from prior review.

Line 33 still targets ^15.5.8, which was previously flagged for advisories. Please move to the first patched 15.x version (or newer supported line).

Check official Next.js advisories/release notes for next@15.5.8 and identify the first patched 15.x version that resolves those advisories.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@package.json` at line 33, Update the "next" dependency in package.json (the
"next" entry currently set to "^15.5.8") to the first patched 15.x release that
resolves the flagged advisories (or to a newer supported release line if
preferred); consult Next.js release notes/security advisories to identify that
exact patched 15.x version and replace the version string accordingly, then run
your lockfile update (npm/yarn/pnpm) and verify the new version is installed and
tests/builds succeed.

app/components/code-graph.tsx (1)

106-110: ⚠️ Potential issue | 🟠 Major

Fix Delete-key handling for single selection and link deletion.

Line 108 is still inverted, and Line 109 always deletes as "nodes" even when selectedObj is a Link. This blocks valid single-delete flows and can target the wrong entity type.

Proposed fix

         const handleKeyDown = (event: KeyboardEvent) => {
             if (event.key === 'Delete') {
-                if (selectedObj && selectedObjects.length === 0) return
-                handleRemove([...selectedObjects.map(obj => obj.id), selectedObj?.id].filter(id => id !== undefined), "nodes");
+                if (!selectedObj && selectedObjects.length === 0) return
+
+                const isSelectedObjLink = !!selectedObj && "source" in selectedObj
+                if (isSelectedObjLink && selectedObjects.length === 0) {
+                    handleRemove([selectedObj.id], "links")
+                    return
+                }
+
+                const nodeIds = [
+                    ...selectedObjects.map(obj => obj.id),
+                    ...(!isSelectedObjLink && selectedObj ? [selectedObj.id] : []),
+                ]
+                if (nodeIds.length === 0) return
+                handleRemove(nodeIds, "nodes")
             }
         };

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/components/code-graph.tsx` around lines 106 - 110, The Delete-key handler
in handleKeyDown incorrectly returns when a single selection exists and always
calls handleRemove with "nodes"; invert the early-return check so it returns
only when there is no selection (i.e., if (!selectedObj &&
selectedObjects.length === 0) return), and determine the correct removal type by
inspecting the selected item(s): if selectedObj?.type === "Link" (or instanceof
Link depending on your model) call handleRemove(..., "links"), otherwise call
handleRemove(..., "nodes"); when mixing selections, compute ids and types
accordingly (e.g., map selectedObjects to their ids and ensure you pass the
appropriate entity type rather than hardcoding "nodes").

.github/dependabot.yml-13-16 (1)

13-16: ⚠️ Potential issue | 🟡 Minor

Group name doesn't match the configured update types.

The group is named npm-minor-patch, suggesting it should include both minor and patch updates, but only patch is specified in update-types. Either:

• Add - "minor" if the intent is to group both minor and patch updates, or
• Rename the group to npm-patch to accurately reflect its scope.

Option A: Include minor updates

     groups:
       npm-minor-patch:
         update-types:
           - "patch"
+          - "minor"

Option B: Rename group to match scope

     groups:
-      npm-minor-patch:
+      npm-patch:
         update-types:
           - "patch"

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/dependabot.yml around lines 13 - 16, The group name
"npm-minor-patch" in the dependabot configuration doesn't match its configured
update-types; either add "- \"minor\"" to the update-types list to include minor
and patch updates, or rename the group to "npm-patch" so the group name reflects
that only patch updates are included—update the groups entry for npm-minor-patch
and the update-types key accordingly.

components/ui/carousel.tsx-109-121 (1)

109-121: ⚠️ Potential issue | 🟡 Minor

Missing cleanup for reInit event listener.

The effect adds listeners for both reInit and select events, but the cleanup only removes the select listener. This could cause a memory leak.

🔧 Proposed fix

       return () => {
+        api?.off("reInit", onSelect)
         api?.off("select", onSelect)
       }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@components/ui/carousel.tsx` around lines 109 - 121, The effect registers both
"reInit" and "select" listeners on the carousel API but only removes "select" on
cleanup; update the cleanup inside the React.useEffect that references api and
onSelect to also call api?.off("reInit", onSelect) (i.e., remove both listeners)
so both event handlers are detached when the effect tears down.

docker-compose.yml-9-10 (1)

9-10: ⚠️ Potential issue | 🟡 Minor

Review the volume mount scope.

Mounting the entire current directory (./) to /data/ could inadvertently expose sensitive files (e.g., .env, .git, credentials) to the container. Consider mounting only the specific directories needed.

🛡️ Proposed fix to limit volume scope

     volumes:
-      - ./:/data/
+      - ./data:/data/

Create a dedicated data directory for FalkorDB persistence.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@docker-compose.yml` around lines 9 - 10, The docker-compose volume mounts the
entire repo (./) into the container as /data/, risking exposure of sensitive
files; change the volume to mount only a dedicated data directory (e.g., create
a local "data" folder) or specific required subfolders instead of "./", and
update the volumes entry (the current "- ./:/data/") to reference that dedicated
directory (or explicit paths) so only FalkorDB persistence data is exposed to
the container.

e2e/tests/nodeDetailsPanel.spec.ts-44-50 (1)

44-50: ⚠️ Potential issue | 🟡 Minor

Assert targetNode exists before clicking by coordinates.

In this flow, targetNode is used directly for screenX/screenY; add a guard to avoid accidental runtime failures.

Suggested fix

       const graphData = await codeGraph.getGraphNodes();
       const targetNode = findNodeByName(graphData, node.nodeName);
+      expect(targetNode).toBeDefined();
+      if (!targetNode) throw new Error(`Node not found: ${node.nodeName}`);
       await codeGraph.nodeClick(targetNode.screenX, targetNode.screenY);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/tests/nodeDetailsPanel.spec.ts` around lines 44 - 50, The test uses
targetNode (returned from findNodeByName) directly for coordinates which can be
undefined; add an explicit guard/assert after obtaining graphData and targetNode
(from getGraphNodes and findNodeByName) to fail fast if targetNode is missing
(e.g., expect(targetNode).toBeDefined() or throw a clear Error) before calling
codeGraph.nodeClick(targetNode.screenX, targetNode.screenY), ensuring the test
doesn't crash with an unclear runtime exception.

e2e/logic/utils.ts-16-35 (1)

16-35: ⚠️ Potential issue | 🟡 Minor

waitForStableText can silently return unstable text on timeout.

Line 34 returns the last sampled text even if stabilization never occurred. That weakens test determinism.

Suggested fix

 export const waitForStableText = async (locator: Locator, timeout: number = 5000): Promise<string> => {
@@
-    return stableText;
+    throw new Error(`Text did not stabilize within ${timeout}ms. Last value: "${stableText}"`);
 };

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/logic/utils.ts` around lines 16 - 35, The waitForStableText helper
(function waitForStableText) currently returns the last sampled text on timeout
which can hide flaky failures; change it so that if the loop finishes without
observing a stable, non-empty value it throws an Error (include the last sampled
text and the timeout value in the message for debugging) instead of returning
stableText, and keep the existing pollingInterval/maxChecks logic and the
locator usage (locator.textContent(), locator.page().waitForTimeout()) intact.

e2e/tests/canvas.spec.ts-128-131 (1)

128-131: ⚠️ Potential issue | 🟡 Minor

Guard fallback arrays before reading .length.

If both shapes are missing, nodes/links become undefined and the length checks crash.

Suggested fix

-      const nodes = result.elements?.nodes || result.nodes;
-      const links = result.elements?.links || result.links;
+      const nodes = result.elements?.nodes ?? result.nodes ?? [];
+      const links = result.elements?.links ?? result.links ?? [];
       expect(nodes.length).toBeGreaterThan(1);
       expect(links.length).toBeGreaterThan(1);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/tests/canvas.spec.ts` around lines 128 - 131, The test currently assumes
nodes and links are arrays and reads .length directly, which will throw if both
result.elements?.nodes and result.nodes are undefined; update the extraction to
ensure a safe array fallback (e.g., use nullish coalescing or an explicit array
check) so nodes and links are always arrays before asserting lengths—refer to
the variables nodes and links and the expressions result.elements?.nodes ||
result.nodes (or replace with result.elements?.nodes ?? result.nodes ?? []) and
similarly for links, then assert against the guaranteed array length.

app/components/toolbar.tsx-10-10 (1)

10-10: ⚠️ Potential issue | 🟡 Minor

Unusual type signature for setCooldownTicks.

The type (ticks?: 0) => void only allows undefined or the literal 0. Based on usage in app/page.tsx and app/components/graphView.tsx, the function is called with -1 as well (e.g., setCooldownTicks(-1)). This type should be widened.

Proposed fix

-    setCooldownTicks: (ticks?: 0) => void
+    setCooldownTicks: (ticks: number | undefined) => void

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/components/toolbar.tsx` at line 10, The type for setCooldownTicks is too
narrow — it currently permits only undefined or the literal 0; update its
signature (in app/components/toolbar.tsx where setCooldownTicks is declared) to
accept a number (e.g., ticks?: number or ticks: number | undefined) so callers
like setCooldownTicks(-1) are allowed; ensure any related usages and prop types
(where ToolbarProps or similar is defined) are updated accordingly to reflect
the widened numeric type.

app/page.tsx-338-346 (1)

338-346: ⚠️ Potential issue | 🟡 Minor

Viewport check may exclude valid canvases.

The visibility check requires the canvas to be fully within the viewport (rect.bottom <= window.innerHeight && rect.right <= window.innerWidth). If the canvas is larger than the viewport or partially scrolled, no canvas will match, causing a silent early return. Consider checking for intersection rather than full containment.

Proposed fix for partial visibility

         // Check if element is actually in viewport
         const rect = container.getBoundingClientRect();
-        const isInViewport = rect.width > 0 &&
-          rect.height > 0 &&
-          rect.top >= 0 &&
-          rect.left >= 0 &&
-          rect.bottom <= window.innerHeight &&
-          rect.right <= window.innerWidth;
+        const isInViewport = rect.width > 0 &&
+          rect.height > 0 &&
+          rect.top < window.innerHeight &&
+          rect.left < window.innerWidth &&
+          rect.bottom > 0 &&
+          rect.right > 0;

         return isInViewport;

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/page.tsx` around lines 338 - 346, The current isInViewport check in
app/page.tsx requires full containment and will miss canvases that are larger
than or partially in view; update the logic around the isInViewport calculation
(the rect checks using rect.top/left/bottom/right and
window.innerHeight/window.innerWidth) to test for intersection instead of full
containment: keep rect.width > 0 && rect.height > 0, then require rect.bottom >
0 && rect.right > 0 && rect.top < window.innerHeight && rect.left <
window.innerWidth so a canvas that is partially visible still counts as
in-viewport.

app/components/graphView.tsx-138-138 (1)

138-138: ⚠️ Potential issue | 🟡 Minor

Double-click threshold of 1000ms is unusually long.

The typical double-click threshold is 300-500ms. A 1000ms threshold may cause unintended double-click detection from separate intentional clicks.

Proposed fix

-        const isDoubleClick = now.getTime() - date.getTime() < 1000 && name === node.data.name
+        const isDoubleClick = now.getTime() - date.getTime() < 400 && name === node.data.name

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/components/graphView.tsx` at line 138, The double-click detection uses a
1000ms window which is too long; update the comparison in the isDoubleClick
computation to use a standard threshold (e.g., 300–500ms) and preferably extract
it to a named constant for clarity. Replace the hardcoded 1000 in the
isDoubleClick expression (where now, date, name and node.data.name are used)
with a constant like DOUBLE_CLICK_THRESHOLD = 500 and compare now.getTime() -
date.getTime() < DOUBLE_CLICK_THRESHOLD so the threshold is easy to adjust and
consistent.

app/components/toolbar.tsx-62-66 (1)

62-66: ⚠️ Potential issue | 🟡 Minor

Guard against undefined handleDownloadImage before invoking.

handleDownloadImage is optional (handleDownloadImage?: () => void), but the onClick handler invokes it without a check. Clicking this button when the prop is undefined will cause a runtime error.

Proposed fix

             <button
                 className="hidden md:block control-button"
                 title="downloadImage"
-                onClick={handleDownloadImage}
+                onClick={() => handleDownloadImage?.()}
             >

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/components/toolbar.tsx` around lines 62 - 66, The Download button calls
the optional handler directly and can throw if undefined; update the onClick
usage in the Toolbar component to guard against undefined handleDownloadImage
(e.g., use a safe call or only attach the handler when present), and consider
disabling the button when handleDownloadImage is not provided so the UI reflects
absence of an action; modify the JSX around the button (the element using
className "hidden md:block control-button" and title "downloadImage") to use
handleDownloadImage?.() or conditionally set onClick/disabled accordingly.

app/components/elementMenu.tsx-125-136 (1)

125-136: ⚠️ Potential issue | 🟡 Minor

Redundant onClick handler on anchor element.

The <a> tag already has href and target="_blank", so the onClick handler that calls window.open with the same URL is redundant and will cause the link to open twice in some browsers.

Proposed fix

                     <a
                         className="p-2"
                         href={objURL}
                         target="_blank"
+                        rel="noopener noreferrer"
                         title="Go to repo"
-                        onClick={() => {
-                            window.open(objURL, '_blank');
-                        }}
                     >
                         <Globe color="white" />
                     </a>

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/components/elementMenu.tsx` around lines 125 - 136, Remove the redundant
onClick handler on the anchor in elementMenu.tsx that calls window.open(objURL,
'_blank'); the <a> already uses href={objURL} and target="_blank", so delete the
onClick={() => { window.open(objURL, '_blank'); }} from the anchor (the element
rendering the Globe icon) to prevent the link from opening twice in some
browsers.

app/components/code-graph.tsx-207-207 (1)

207-207: ⚠️ Potential issue | 🟡 Minor

Use block syntax for forEach callbacks to avoid implicit return values.

Lines 207 and 411 have arrow function callbacks with implicit returns (from Set.add(...) and assignment), making the intent unclear and inconsistent with other forEach calls in the file.

Proposed fixes

-        deleteNeighbors(expandedNodes)?.forEach(id => deleteIdsMap.add(id))
+        deleteNeighbors(expandedNodes)?.forEach(id => {
+            deleteIdsMap.add(id)
+        })

-                                                    graph.Categories.forEach(c => c.show = true);
+                                                    graph.Categories.forEach(c => {
+                                                        c.show = true
+                                                    });

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/components/code-graph.tsx` at line 207, The forEach callbacks use concise
arrow expressions that rely on implicit returns (e.g.,
deleteNeighbors(expandedNodes)?.forEach(id => deleteIdsMap.add(id))), which is
inconsistent and unclear; update these to use block-bodied arrow functions with
explicit statements (e.g., id => { deleteIdsMap.add(id); }) so intent is clear
and matches other forEach usages — locate the occurrences around deleteNeighbors
and the similar callback at line ~411 and replace the concise arrow bodies with
block bodies containing explicit calls or assignments.

e2e/config/constants.ts (1)

3-3: Fix the exported constant typo before it spreads (CHAT_OPTTIONS_COUNT).
Line 3 exports a misspelled public identifier. Consider adding a correctly spelled alias and keeping the old name temporarily for compatibility.

Proposed non-breaking cleanup

-export const CHAT_OPTTIONS_COUNT = 6;
+export const CHAT_OPTIONS_COUNT = 6;
+export const CHAT_OPTTIONS_COUNT = CHAT_OPTIONS_COUNT; // backward compatibility alias

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/config/constants.ts` at line 3, Export a correctly spelled constant name
and keep the misspelled one as a backward-compatible alias: add a new exported
symbol CHAT_OPTIONS_COUNT with the same value as the existing
CHAT_OPTTIONS_COUNT and re-export the old CHAT_OPTTIONS_COUNT (or assign it from
the new constant) so consumers using the misspelled identifier keep working
while code is migrated to CHAT_OPTIONS_COUNT.

lib/utils.ts (1)

7-10: Avoid any[] in shared graph/message contracts.
Lines 8-9 and Line 34 remove most type safety from the new centralized model. Use concrete types and reuse PathData in Message to prevent drift.

Proposed typing cleanup

 export type PathData = {
-  nodes: any[]
-  links: any[]
+  nodes: Node[]
+  links: Link[]
 }
@@
 export interface Message {
   type: MessageTypes;
   text?: string;
-  paths?: { nodes: any[], links: any[] }[];
+  paths?: PathData[];
   graphName?: string;
 }

Also applies to: 31-35

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@lib/utils.ts` around lines 7 - 10, The PathData type uses any[] for nodes and
links and the Message type (referenced in this file) duplicates loose typing;
replace any[] with concrete, shared types (e.g., define Node and Link interfaces
or reuse existing ones) and update PathData to nodes: Node[] and links: Link[];
then change Message to reference PathData instead of duplicating fields so both
the graph contract and Message reuse the same strongly typed structure (update
all occurrences of PathData, Message, Node, and Link in this module).

components/ui/carousel.tsx (2)

88-99: Keyboard navigation doesn't account for vertical orientation.

The handleKeyDown uses ArrowLeft/ArrowRight regardless of orientation. For vertical carousels, ArrowUp/ArrowDown would be more intuitive.

♻️ Proposed enhancement

     const handleKeyDown = React.useCallback(
       (event: React.KeyboardEvent<HTMLDivElement>) => {
-        if (event.key === "ArrowLeft") {
+        const prevKey = orientation === "horizontal" ? "ArrowLeft" : "ArrowUp"
+        const nextKey = orientation === "horizontal" ? "ArrowRight" : "ArrowDown"
+        if (event.key === prevKey) {
           event.preventDefault()
           scrollPrev()
-        } else if (event.key === "ArrowRight") {
+        } else if (event.key === nextKey) {
           event.preventDefault()
           scrollNext()
         }
       },
-      [scrollPrev, scrollNext]
+      [orientation, scrollPrev, scrollNext]
     )

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@components/ui/carousel.tsx` around lines 88 - 99, handleKeyDown always maps
ArrowLeft/ArrowRight to scrollPrev/scrollNext, which ignores vertical carousels;
update handleKeyDown to branch on the carousel orientation (e.g., an orientation
prop or isVertical flag) and use ArrowUp/ArrowDown for vertical mode while
keeping ArrowLeft/ArrowRight for horizontal mode, still calling scrollPrev and
scrollNext and calling event.preventDefault() for handled keys; locate the
callback by name handleKeyDown and update its dependency array if you reference
any new orientation variable.

---

208-214: Minor: Remove extra space in className.

There's a double space between absolute and h-8.

🔧 Proposed fix

-        "absolute  h-8 w-8 rounded-full",
+        "absolute h-8 w-8 rounded-full",

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@components/ui/carousel.tsx` around lines 208 - 214, The className string
passed to the cn() call in the Carousel component has an extra space between
"absolute" and "h-8"; update the class string inside the className prop (the
cn(...) expression in components/ui/carousel.tsx where the element builds
"absolute  h-8 w-8 rounded-full") to remove the double space so it becomes
"absolute h-8 w-8 rounded-full".

README.md (1)

3-3: Consider using h2 for consistent heading levels.

The heading jumps from h1 (#) directly to h3 (###). For proper document structure, consider using h2 (##) instead.

📝 Proposed fix

-### Visualize your repository with our graph for code analysis
+## Visualize your repository with our graph for code analysis

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@README.md` at line 3, The heading "Visualize your repository with our graph
for code analysis" is an h3 while the document starts with h1; change this
header from "### Visualize your repository with our graph for code analysis" to
an h2 by replacing the three hashes with two ("##") so heading levels are
consistent and follow the h1 -> h2 structure in README.md.

e2e/logic/POM/codeGraph.ts (1)

403-403: Magic number for animation delay.

The 2000ms timeout is a hardcoded magic number. Consider extracting it to a named constant or making it configurable for better maintainability.

Proposed fix

+const GRAPH_ANIMATION_DELAY = 2000;
+
 // In selectGraph method:
-        await this.page.waitForTimeout(2000); // graph animation delay
+        await this.page.waitForTimeout(GRAPH_ANIMATION_DELAY);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/logic/POM/codeGraph.ts` at line 403, The hardcoded 2000ms in the call to
this.page.waitForTimeout(2000) is a magic number; extract it into a named
constant (e.g., ANIMATION_DELAY_MS) or make it configurable (pass as a parameter
or read from a config) and replace the literal in the method in codeGraph.ts so
the delay is maintainable and easy to adjust; update any related tests or usages
to reference the new constant/config option.

app/components/ForceGraph.tsx (2)

154-156: Remove unused canvasRef from handleEngineStop dependencies.

canvasRef is listed in the dependency array but is not used in the callback body. This can cause unnecessary re-creations of the callback.

Proposed fix

     const handleEngineStop = useCallback(() => {
         onEngineStop()
-    }, [canvasRef, onEngineStop])
+    }, [onEngineStop])

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/components/ForceGraph.tsx` around lines 154 - 156, The handleEngineStop
useCallback includes an unused dependency canvasRef which causes needless
re-creations; update the dependency array for handleEngineStop to only include
onEngineStop (i.e., useCallback(() => { onEngineStop() }, [onEngineStop])) so
the callback only re-creates when onEngineStop changes and remove canvasRef from
the dependency list.

---

106-151: Consider memoizing node/link lookups for better performance.

The event handlers use data.nodes.find() and data.links.find() which are O(n) operations. For large graphs, this could impact performance during rapid interactions like hovering. Consider using a Map for O(1) lookups.

Proposed optimization

+// Add memoized maps
+const nodesMap = useMemo(() => new Map(data.nodes.map(n => [n.id, n])), [data.nodes])
+const linksMap = useMemo(() => new Map(data.links.map(l => [l.id, l])), [data.links])

 // Map node click handler
 const handleNodeClick = useCallback((node: GraphNode, event: MouseEvent) => {
-    const originalNode = data.nodes.find(n => n.id === node.id)
+    const originalNode = nodesMap.get(node.id)
     if (originalNode) onNodeClick(originalNode, event)
-}, [onNodeClick, data.nodes])
+}, [onNodeClick, nodesMap])

Apply the same pattern to all other handlers (handleNodeHover, handleNodeRightClick, handleLinkClick, handleLinkHover, handleLinkRightClick).

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/components/ForceGraph.tsx` around lines 106 - 151, Replace repeated O(n)
searches in handlers by building memoized lookup maps for nodes and links (e.g.,
nodeById and linkById) using useMemo derived from data.nodes and data.links,
then change handleNodeClick, handleNodeHover, handleNodeRightClick,
handleLinkClick, handleLinkHover, and handleLinkRightClick to use
nodeById.get(node.id) / linkById.get(link.id) for O(1) lookups; update each
handler's dependency array to depend on the corresponding memoized map (not the
raw arrays) and preserve the current null-check behavior in
handleNodeHover/handleLinkHover.

app/components/elementMenu.tsx (1)

145-161: Redundant type cast after type guard.

After the "category" in obj check on line 146, TypeScript narrows obj to Node. The explicit cast obj as Node on lines 150 and 156 is redundant and can be removed for cleaner code.

Proposed refactor

             {
                 "category" in obj &&
                 <>
                     <button
                         className="p-2"
-                        onClick={() => handleExpand([obj as Node], true)}
+                        onClick={() => handleExpand([obj], true)}
                     >
                         <Maximize2 color="white" />
                     </button>
                     <button
                         className="p-2"
-                        onClick={() => handleExpand([obj as Node], false)}
+                        onClick={() => handleExpand([obj], false)}
                     >
                         <Minimize2 color="white" />
                     </button>
                 </>
             }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/components/elementMenu.tsx` around lines 145 - 161, The "category" in obj
type guard already narrows obj to Node, so remove the redundant casts obj as
Node in the two onClick handlers and pass obj directly to handleExpand; update
both calls inside the fragment (the Maximize2 and Minimize2 buttons) to use
handleExpand([obj], true/false) so the code is cleaner and leverages
TypeScript's narrowing (symbols: obj, Node, handleExpand).

Configuration used: defaults

Review profile: CHILL

Plan: Pro